package br.com.foxinline.manager.pesquisar;

import br.com.foxinline.enums.*;
import br.com.foxinline.manager.generico.ManagerPesquisarGenerico;
import br.com.foxinline.manager.iptu.ManagerIPTU;
import br.com.foxinline.modelo.*;
import br.com.foxinline.servico.*;
import br.com.foxinline.util.*;
import java.beans.Transient;
import java.io.*;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.ejb.EJB;
import javax.ejb.EJBAccessException;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;
import javax.servlet.http.HttpServletRequest;
import org.primefaces.component.datatable.DataTable;
import org.primefaces.context.RequestContext;
import org.primefaces.event.SelectEvent;
import org.primefaces.event.UnselectEvent;
import org.primefaces.event.map.OverlaySelectEvent;
import org.primefaces.model.chart.PieChartModel;
import org.primefaces.model.map.*;

/**
 *
 * @author ely
 */
@ManagedBean
@ViewScoped
public class ManagerPesquisarImovel extends ManagerPesquisarGenerico<Imovel> {

    @EJB
    AnexoServico anexoServico;
    @EJB
    ImovelServico imovelServico;
    @EJB
    AverbacaoServico averbacaoServico;
    @EJB
    BairroServico bairroServico;
    @EJB
    UsuarioServico usuarioServico;
    @EJB
    ItbiServico itbiServico;
    @EJB
    HistoricoRevisaoAlinhamentoServico historicoRevisaoAlinhamentoServico;
    @EJB
    PrefeituraServico prefeituraServico;
    @EJB
    IptuServico iptuServico;
    @EJB
    ForusServico forusServico;
    @EJB
    CidadeServico cidadeServico;
    private Imovel imovel;
    private List<Imovel> imoveis;
    private Proprietario proprietario;
    private Endereco endereco;
    private String vImovel;
    private Imovel visaoImovel;
    private Imovel imovelDelete;
    // Georreferenciamento Coordenada
    LatLng latlong;
    private Coordenada coordenada;
    private List<Coordenada> coordenadas;
    private MapModel mapModel;
    private MapModel mapModelDimensao;
    private Polygon polygon;
    private Coordenada visualizarCoordenada;
    private Imovel imovelAverbacao;
    private String center;
    private Integer zoom;
    private String centerDimensao;
    private Integer zoomDimensao;
    private String visaoInscricao = "";
    private List<Imovel> imoveisPendentes;
    private List<Imovel> resultPendentes;
    // Gráfico
    private PieChartModel graficoModel;
    private String grupo;
    private Bairro bairro;
    private List<String> selectedOptions;
    private static final String pendenteProprietario = "Proprietário";
    private static final String pendenteDocumentos = "Documentos";
    // Anexos
    private List<Anexo> annexs;
    private List<Anexo> annexCroquis;
    private boolean connect;
    private boolean btGerarIptu;
    private List<Iptu> lstIptus;
    private Integer qtdParcelas;
    private boolean soResultado;
    private String cpf;
    private String inscricaoImovel;
    private List<Parcela> parcelas;
    private TreeMap<String, String> selectParcelas;
    private Proprietario proprietarioVisualizar;
    private boolean registroAlteracao;
    private boolean inclusao;
    private boolean alteracao;
    /**
     * Pesquisa Avançada
     */
    private Boolean imovelComNumero;
    private Boolean imovelComCroqui;
    private Boolean imovelComAnexo;
    private Boolean imovelComProprietario;
    private Boolean imovelComDimensoes;
    private Boolean imovelComConfrontacao;
    private Boolean imovelComCoordenadasDimensoes;
    private List<Bairro> bairrosSelecionados;
    private String inscricaoCadastralQuadra = "";
    //Merge
    private String vReg;
    private Imovel imovelSelected;
    /**
     * Alternar Imóveis na tela de visualizar
     */
    private Long proximoImovel;
    private Long imovelAnterior;
    private ArquivoUtilitario arquivoUtilitario;

    @Override
    public void init() {
        setServico(imovelServico);
        this.searchResults = new DataTable();

        this.bairrosSelecionados = new ArrayList<Bairro>();

        this.imovel = new Imovel();
        this.lstIptus = new ArrayList<Iptu>();

        this.endereco = new Endereco();

        this.proprietario = new Proprietario();

        this.proprietarioVisualizar = new Proprietario();
        this.proprietarioVisualizar.setTipoDocumento(TipoDocumento.CPF);

        this.coordenada = new Coordenada();
        this.coordenadas = new ArrayList<Coordenada>();

        this.resultPendentes = new ArrayList<Imovel>();

        this.bairro = new Bairro();

        this.selectedOptions = new ArrayList<String>();

        this.center = prefeituraServico.getCentroMapa();
        this.zoom = prefeituraServico.getZoomMapa();

        this.centerDimensao = prefeituraServico.getCentroMapa();
        this.zoomDimensao = prefeituraServico.getZoomMapa();

        this.imoveis = new ArrayList<Imovel>();

        Map<String, String> params = FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap();
        this.vImovel = params.get("vImovel");
        this.cpf = params.get("cpf");
        this.inscricaoImovel = params.get("inscricaoimovel");
        this.vReg = params.get("vReg");
        paramPost();
        this.btGerarIptu = false;

        this.parcelas = new ArrayList<Parcela>();
        Map<String, String> select = new HashMap<String, String>();
        boolean maior = true;
        if (this.visaoImovel != null) {
            List<Iptu> iptus = iptuServico.findIptuByImovelId(this.visaoImovel.getId());
            if (iptus != null && !iptus.isEmpty()) {
                this.parcelas = iptus.get(0).getParcelas();
                Collections.sort(this.parcelas, new Comparator<Parcela>() {
                    @Override
                    public int compare(Parcela p1, Parcela p2) {
                        if (p1.getIndice() < p2.getIndice()) {
                            return -1;
                        } else {
                            return 1;
                        }
                    }
                });
                this.qtdParcelas = this.parcelas.size() - 1;

                for (int i = 1; i < 13; i++) {
                    if ((iptus.get(0).getValorBaseCorrigido().divide(new BigDecimal(i), 2, RoundingMode.HALF_UP)).compareTo(new BigDecimal(25.40)) >= 0) {
                        select.put(i + "x", i + "");
                    }
                    maior = false;
                }
            }
        }
        if (select.isEmpty() & maior) {
            for (int i = 1; i < 13; i++) {
                select.put(i + "x", i + "");
            }
        } else {
            if (select.isEmpty()) {
                select.put(1 + "x", 1 + "");
            }
        }
        this.selectParcelas = new TreeMap(new ValueComparator(select));
        this.selectParcelas.putAll(select);
//        createGraficoModel();

        if (this.visaoImovel != null && this.visaoImovel.getId() != null) {
            this.proximoImovel = imovelServico.pesquisarProximoImovel(this.visaoImovel.getId());
            this.imovelAnterior = imovelServico.pesquisarImovelAnterior(this.visaoImovel.getId());
        }
    }

    /**
     * método utilizado para pesquisar imóvel por: proprietário, endereço, imóvel.
     */
    public void pesquisarImovel() {

        List<Integer> quadras = formatarInscricaoCadastralQuadras();

        if (quadras == null) {
            return;
        }

        imovelServico.setImovelComNumero(this.imovelComNumero);
        imovelServico.setImovelComAnexo(this.imovelComAnexo);
        imovelServico.setImovelComCroqui(this.imovelComCroqui);
        imovelServico.setImovelComProprietario(this.imovelComProprietario);
        imovelServico.setImovelComDimensao(this.imovelComDimensoes);
        imovelServico.setImovelComConfrontacao(this.imovelComConfrontacao);
        imovelServico.setImovelComCoordenadaConfrontacao(this.imovelComCoordenadasDimensoes);
        imovelServico.setImovelQuadras(quadras);
        setServico(imovelServico);

        this.proprietario.setCpf(Caracter.removecaracter(this.proprietario.getCpf()));
        this.proprietario.setCnpj(Caracter.removecaracter(this.proprietario.getCnpj()));

        this.endereco.setCep(Caracter.removecaracter(this.endereco.getCep()));

        this.imovel.setProprietarios(new ArrayList<Proprietario>());

        if (!this.proprietario.equals(new Proprietario())) {
            this.imovel.getProprietarios().add(this.proprietario);
        }

        this.imovel.setEnderecoImovel(this.endereco);

        if (this.visaoInscricao != null && !this.visaoInscricao.isEmpty()) {
            String[] str = this.visaoInscricao.split("\\.");
            try {
                this.imovel.setInscricaoCadastralD(Integer.parseInt(str[0]) == 0 ? null : Integer.parseInt(str[0]));
            } catch (NumberFormatException e) {
                this.imovel.setInscricaoCadastralD(null);
            } catch (Exception e) {
            }
            try {
                this.imovel.setInscricaoCadastralS(Integer.parseInt(str[1]) == 0 ? null : Integer.parseInt(str[1]));
            } catch (NumberFormatException e) {
                this.imovel.setInscricaoCadastralS(null);
            } catch (Exception e) {
            }
            try {
                this.imovel.setInscricaoCadastralQuadra(Integer.parseInt(str[2]) == 0 ? null : Integer.parseInt(str[2]));
            } catch (NumberFormatException e) {
                this.imovel.setInscricaoCadastralQuadra(null);
            } catch (Exception e) {
            }
            try {
                this.imovel.setInscricaoCadastralLote(Integer.parseInt(str[3]) == 0 ? null : Integer.parseInt(str[3]));
            } catch (NumberFormatException e) {
                this.imovel.setInscricaoCadastralLote(null);
            } catch (Exception e) {
            }
            try {
                this.imovel.setInscricaoCadastralUnid(Integer.parseInt(str[4]) == 0 ? null : Integer.parseInt(str[4]));
            } catch (NumberFormatException e) {
                this.imovel.setInscricaoCadastralUnid(null);
            } catch (Exception e) {
            }
        }

        this.entidadePesquisar = this.imovel;

//        getSearchResults().setFirst(0);
//        onLoadModel();
        this.imoveis = imovelServico.find(this.imovel, null, null);

        if (this.imoveis == null) {
            this.btGerarIptu = true;
        } else {
            this.btGerarIptu = false;
        }
    }

    public void gerarIPTU() {
        ManagerIPTU mIptu = new ManagerIPTU();
        mIptu.gerarIPTU(imovel);
    }

    public void pesquisarImovelIPTU() {

        if ((proprietario.getCpf() == null || proprietario.getCpf().isEmpty())
                && (proprietario.getNome() == null || proprietario.getNome().isEmpty())
                && (visaoInscricao == null || visaoInscricao.isEmpty())) {

            Msg.messagemWarn("Informe pelo menos um campo !");
            return;
        }

        if (proprietario.getCpf() != null && !proprietario.getCpf().isEmpty()) {

            proprietario.setCpf(Caracter.removecaracter(proprietario.getCpf()));

            if (proprietario.getCpf().length() == 14) {

                proprietario.setCnpj(proprietario.getCpf());
                proprietario.setCpf(null);

            } else if (proprietario.getCpf().length() == 11) {

                proprietario.setCnpj(null);
            } else {
                Msg.messagemError("Informe um CPF/CNPJ válido !");
            }
        }

        if (visaoInscricao != null && !visaoInscricao.isEmpty()) {

            try {
                String[] str = visaoInscricao.split("\\.");

                this.imovel.setInscricaoCadastralD(Integer.parseInt(str[0]));
                this.imovel.setInscricaoCadastralS(Integer.parseInt(str[1]));
                this.imovel.setInscricaoCadastralQuadra(Integer.parseInt(str[2]));
                this.imovel.setInscricaoCadastralLote(Integer.parseInt(str[3]));
                this.imovel.setInscricaoCadastralUnid(Integer.parseInt(str[4]));

            } catch (Exception e) {
                System.err.println(e);
            }
        }

        List<Imovel> results = imovelServico.find(this.imovel, null, null);

        if (results == null || results.isEmpty()) {
            Msg.messagemWarn("Nenhum imóvel foi encontrado !");
        } else if (results.size() == 1) {

            try {
                FacesContext.getCurrentInstance().getExternalContext().redirect("visualizarimovel.xhtml?vImovel=" + results.get(0).getId());
            } catch (IOException ex) {
                Logger.getLogger(Msg.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    @Override
    public void limpar() {
        this.imovel = new Imovel();
        this.proprietario = new Proprietario();
        this.proprietario.setTipoDocumento(TipoDocumento.CPF);
        this.endereco = new Endereco();
        this.imovelComNumero = null;
        this.alteracao = false;
        this.inclusao = false;
        this.inscricaoCadastralQuadra = "";
    }

    /**
     * método usuado para visualizar coordendas no gmap
     */
    public void plotar() {
        mapModel = new DefaultMapModel();
        if (!coordenadas.isEmpty()) {
            for (Coordenada c : coordenadas) {
                LatLng coord = new LatLng(c.getLat(), c.getLog());
                center = c.getLat() + ", " + c.getLog();
                mapModel.addOverlay(new Marker(coord, visaoImovel.getProprietarios() + "", "Imóvel", getRequestURL().concat("/media/images/imovel.png")));
            }
            zoom = 17;
        }
    }

    /**
     * método usuado para visualizar coordendas no gmap
     */
    public void plotarCoordenadasDimensoes() {

        this.mapModelDimensao = new DefaultMapModel();
        this.polygon = new Polygon();

        LatLng coord;

        if (!this.visaoImovel.getCoordenadasDimensoes().isEmpty()) {

            Marker marker;

            for (Coordenada c : this.visaoImovel.getCoordenadasDimensoes()) {
                coord = new LatLng(c.getLat(), c.getLog());

                marker = new Marker(coord, c.getPonto(), c, null);

                this.centerDimensao = c.getLat() + ", " + c.getLog();

                this.mapModelDimensao.addOverlay(marker);

                this.polygon.getPaths().add(coord);
                this.polygon.setStrokeColor("#FF9900");
                this.polygon.setFillColor("#FF9900");
                this.polygon.setFillOpacity(0);

                this.mapModelDimensao.addOverlay(this.polygon);
            }

            this.zoomDimensao = 17;

            this.mapModelDimensao.addOverlay(this.polygon);
        }
    }

    @Transient
    private String getRequestURL() {
        FacesContext context = FacesContext.getCurrentInstance();
        HttpServletRequest request = (HttpServletRequest) context.getExternalContext().getRequest();
        String requestURL = request.getRequestURL().toString();
        String url = requestURL.substring(0, requestURL.lastIndexOf("/"));
        return url;
    }

    public String proprietarios(Imovel imovel) {
        return averbacaoServico.getNomeProprietarios(imovel.getProprietarios());
    }

    public String proprietariosDocumento(Imovel imovel) {
        return averbacaoServico.getDocumentoProprietarios(imovel.getProprietarios());
    }

    public String getCenter() {
        return center;
    }

    public void setCenter(String center) {
        this.center = center;
    }

    public void visualizarCoordenada(Coordenada coordenada) {
        this.visualizarCoordenada = coordenada;
    }

    public void visualizarCoordenadaMapa(OverlaySelectEvent event) {
        this.visualizarCoordenada = (Coordenada) ((Marker) event.getOverlay()).getData();
    }

    public void paramPost() {
        try {
            if (vImovel != null) {
                visaoImovel = imovelServico.find(Long.parseLong(vImovel));
                visaoImovel.setProprietarios(imovelServico.lstProprietario(visaoImovel));

                annexs = imovelServico.lstAnnexs(visaoImovel);
                if (annexs == null || annexs.isEmpty()) {
                    annexs = new ArrayList<Anexo>();
                }

                atualizarAnexos(annexs);

                annexCroquis = imovelServico.lstAnnexCroqui(visaoImovel);
                if (annexCroquis == null || annexCroquis.isEmpty()) {
                    annexCroquis = new ArrayList<Anexo>();
                }

                atualizarAnexos(annexCroquis);

                coordenadas = imovelServico.lstCoordenadas(visaoImovel);

                this.visaoImovel.setCoordenadasDimensoes(imovelServico.lstCoordenadasDimensoes(this.visaoImovel));

                if (visaoImovel.getEnderecoImovel() == null) {
                    visaoImovel.setEnderecoImovel(new Endereco());
                }
                if (visaoImovel.getEnderecoCorrespondencia() == null) {
                    visaoImovel.setEnderecoCorrespondencia(new Endereco());
                }
                if (visaoImovel.getDimensoes() == null) {
                    visaoImovel.setDimensoes(new Dimensao());
                }

                if (visaoImovel.getEnderecoImovel() != null && visaoImovel.getEnderecoImovel().getBairroDne() == null) {
                    visaoImovel.getEnderecoImovel().setBairroDne(new Bairro());
                }

                if (visaoImovel.getEnderecoCorrespondencia() != null && visaoImovel.getEnderecoCorrespondencia().getBairroDne() == null) {
                    visaoImovel.getEnderecoCorrespondencia().setBairroDne(new Bairro());
                }

                lstIptus = iptus(visaoImovel);

                DecimalFormat d = new DecimalFormat("");
                d.setMinimumIntegerDigits(2);

                visaoInscricao += d.format(visaoImovel.getInscricaoCadastralD() == null ? 0 : visaoImovel.getInscricaoCadastralD());
                visaoInscricao += d.format(visaoImovel.getInscricaoCadastralS() == null ? 0 : visaoImovel.getInscricaoCadastralS());
                d.setMinimumIntegerDigits(3);
                visaoInscricao += d.format(visaoImovel.getInscricaoCadastralQuadra() == null ? 0 : visaoImovel.getInscricaoCadastralQuadra());
                d.setMinimumIntegerDigits(4);
                d.setDecimalSeparatorAlwaysShown(false);
                visaoInscricao += d.format(visaoImovel.getInscricaoCadastralLote() == null ? 0 : visaoImovel.getInscricaoCadastralLote());
                d.setMinimumIntegerDigits(2);
                visaoInscricao += d.format(visaoImovel.getInscricaoCadastralUnid() == null ? 0 : visaoImovel.getInscricaoCadastralUnid());

                visaoInscricao = visaoInscricao.replace(",", "").replace(".", "");

                if (this.visaoImovel.getComando() != null) {
                    registroAlteracao = visaoImovel.getComando().equals(Comando.ALTERACAO);
                }

                if (prefeituraServico.find().getDesabilitarMapas()) {

                    this.connect = false;
                } else if (!Conexao.isInternetReachable()) {

                    this.connect = false;
                    Msg.messagemWarn("Não foi possível estabelecer uma conexão com a Internet.");
                } else {
                    this.connect = true;
                    plotar();
                    plotarCoordenadasDimensoes();
                }
            }
            if (FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap().get("p") != null) {
                if (FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap().get("p").equals("true")) {
                    imovelPendente();
                }
            }
        } catch (Exception e) {
            System.err.println(e);
        }

        pesquisaPrincipal();
    }

    public int anoIptu(Iptu iptuParam) {
        Calendar cal = GregorianCalendar.getInstance();
        cal.setTime(iptuParam.getDataIptu());
        int x = cal.get(Calendar.YEAR);
        return x;
    }

    public int anoForus(Forus iptuParam) {
        Calendar cal = GregorianCalendar.getInstance();
        cal.setTime(iptuParam.getDataForus());
        int x = cal.get(Calendar.YEAR);
        return x;
    }

    public List<Iptu> iptus(Imovel imovel) {
        if (imovel != null && imovel.getId() != null) {
            return iptuServico.findValidIptuByImovelId(imovel.getId());
        }
        return new ArrayList<Iptu>();
    }

    public boolean existeParcelaPendencia(Iptu iptuParam) {

        List<Parcela> parcelasIptu = iptuServico.parcelas(iptuParam);

        if (parcelasIptu != null && !parcelasIptu.isEmpty()) {

            if (parcelasIptu.get(0).getPago() || (parcelasIptu.get(0).getBaixaManual() != null && parcelasIptu.get(0).getBaixaManual())) {
                return false;
            } else {
                if (parcelasIptu.size() == 4 && (parcelasIptu.get(1).getPago() || (parcelasIptu.get(1).getBaixaManual() != null && parcelasIptu.get(1).getBaixaManual()))
                        && (parcelasIptu.get(2).getPago() || (parcelasIptu.get(2).getBaixaManual() != null && parcelasIptu.get(2).getBaixaManual()))
                        && (parcelasIptu.get(3).getPago() || (parcelasIptu.get(3).getBaixaManual() != null && parcelasIptu.get(3).getBaixaManual()))) {
                    return false;
                } else {
                    if (parcelasIptu.size() == 3 && (parcelasIptu.get(1).getPago() || (parcelasIptu.get(1).getBaixaManual() != null && parcelasIptu.get(1).getBaixaManual()))
                            && (parcelasIptu.get(2).getPago() || (parcelasIptu.get(0).getBaixaManual() != null && parcelasIptu.get(0).getBaixaManual()))) {
                        return false;
                    } else {
                        return true;
                    }
                }
            }
        } else {
            return true;
        }
    }

    public List<Parcela> parcelas(Iptu iptu) {
        List<Parcela> parcelasIptu = iptuServico.parcelas(iptu);

        if (parcelasIptu != null && !parcelasIptu.isEmpty()) {
            for (Parcela parcela : parcelasIptu) {
                if (parcela.getIndice() == 0 && ((parcela.getPago() != null && parcela.getPago()) || (parcela.getBaixaManual() != null && parcela.getBaixaManual()))) {
                    parcelasIptu = new ArrayList<Parcela>();
                    parcelasIptu.add(parcela);
                }
            }
        }

        return parcelasIptu;
    }

    public void relatorioBCI(boolean imprimirAnexos) {
        HashMap parametros = new HashMap();

        proprietario.setCpf(Caracter.removecaracter(proprietario.getCpf()));
        proprietario.setCnpj(Caracter.removecaracter(proprietario.getCnpj()));
        endereco.setCep(Caracter.removecaracter(endereco.getCep()));

        parametros.putAll(prefeituraServico.parametroPrefeitura());

        imovelServico.reportsAtlasMobileRegImovel(parametros, imovel, proprietario, endereco, imprimirAnexos);

        RequestContext requestContext = RequestContext.getCurrentInstance();
        requestContext.execute("dlgBCI.hide()");
    }

    public void imprimirBCI(boolean imprimirAnexos) {

        HashMap parametros = new HashMap();
        parametros.putAll(prefeituraServico.parametroPrefeitura());

        List<Imovel> imoveisBCI = new ArrayList<Imovel>();
        imoveisBCI.add(imovelServico.find(this.visaoImovel.getId()));

        imovelServico.relatorioBCI(parametros, imoveisBCI, imprimirAnexos);
    }

    public void relatorioVisaoImovel() {
        List<Imovel> list = new ArrayList<Imovel>();
        list.add(visaoImovel);
        imovelServico.relatorioBCI(new HashMap(), list, false);
    }

    public void imovelPendente() {

        if (!selectedOptions.isEmpty()) {
            if (selectedOptions.size() == 1) {
                if (selectedOptions.get(0).equals(pendenteDocumentos)) {
                    resultPendentes = imovelServico.imovelPendente(grupo, bairro, null, pendenteDocumentos);
                } else {
                    resultPendentes = imovelServico.imovelPendente(grupo, bairro, pendenteProprietario, null);
                }
            } else if (selectedOptions.size() == 2) {
                resultPendentes = imovelServico.imovelPendente(grupo, bairro, pendenteProprietario, pendenteDocumentos);
            }
        } else {
            resultPendentes = imovelServico.imovelPendente(grupo, bairro, null, null);
        }

    }

    /**
     * Relatório usado para a relação cadastral diferente do BCI
     */
    public void relatorioRelacaoCadastral() {
        HashMap parametros = new HashMap();
        proprietario.setCpf(Caracter.removecaracter(proprietario.getCpf()));
        proprietario.setCnpj(Caracter.removecaracter(proprietario.getCnpj()));
        endereco.setCep(Caracter.removecaracter(endereco.getCep()));

        parametros.putAll(prefeituraServico.parametroPrefeitura());

        imovelServico.relatorioRelacaoCadastral(parametros, imovel, proprietario, endereco);
    }

    public void relatorioRelacaoImoveisSimplificado() {

        HashMap parametros = new HashMap();

        this.proprietario.setCpf(Caracter.removecaracter(this.proprietario.getCpf()));
        this.proprietario.setCnpj(Caracter.removecaracter(this.proprietario.getCnpj()));
        this.endereco.setCep(Caracter.removecaracter(this.endereco.getCep()));

        this.imovel.setProprietarios(new ArrayList<Proprietario>());
        this.imovel.getProprietarios().add(this.proprietario);
        this.imovel.setEnderecoImovel(this.endereco);

        parametros.putAll(prefeituraServico.parametroPrefeitura());

        imovelServico.setOrderBy("inscricaoCadastralQuadra");

        imovelServico.relatorioRelacaoImoveisSimplificado(parametros, imovelServico.find(this.imovel, null, null));
    }

    public void relatorioPendenciaAreaCessao() {

        HashMap parametros = new HashMap();

//        this.proprietario.setCpf(Caracter.removecaracter(this.proprietario.getCpf()));
//        this.proprietario.setCnpj(Caracter.removecaracter(this.proprietario.getCnpj()));
//        this.endereco.setCep(Caracter.removecaracter(this.endereco.getCep()));
//
//        this.imovel.setProprietarios(new ArrayList<Proprietario>());
//        this.imovel.getProprietarios().add(this.proprietario);
//        this.imovel.setEnderecoImovel(this.endereco);

        parametros.putAll(prefeituraServico.parametroPrefeitura());

//        imovelServico.relatorioPendenciaAreaCessao(parametros, imovelServico.find(this.imovel, null, null));
        imovelServico.relatorioPendenciaAreaCessao(parametros, this.imoveis);
    }

    public void pesquisarRelatorioGeral() {
        List<Integer> quadras = formatarInscricaoCadastralQuadras();

        if (quadras == null) {
            return;
        }

        this.endereco.setCep(Caracter.removecaracter(this.endereco.getCep()));

        this.imovel.setEnderecoImovel(this.endereco);

        if (!this.proprietario.equals(new Proprietario())) {
            this.imovel.setProprietarios(new ArrayList<Proprietario>());
            this.imovel.getProprietarios().add(this.proprietario);
        }

        imovelServico.setImovelComCroqui(this.imovelComCroqui);
        imovelServico.setImovelComNumero(this.imovelComNumero);
        imovelServico.setBairros(this.bairrosSelecionados);
        imovelServico.setImovelQuadras(quadras);

        this.imoveis = imovelServico.find(this.imovel, null, null);

        if (this.imoveis == null || this.imoveis.isEmpty()) {
            Msg.messagemWarn("Nenhum resultado encontrado !");
        } else {
            RequestContext.getCurrentInstance().execute("imprimir.jq.click()");
        }
    }

    /**
     * Relatório De Cessão
     */
    public void relatorioGeral() {
        HashMap parametros = new HashMap();

        parametros.put("titulo", "Relatório");
        parametros.putAll(prefeituraServico.parametroPrefeitura());

        imovelServico.relatorioGeral(parametros, this.imoveis);

    }

    public void relPendente() {
        imovelServico.relatorioPendencia(this.resultPendentes);
    }

    public void redirect(String url) throws IOException {
        ExternalContext context = FacesContext.getCurrentInstance().getExternalContext();
        context.redirect(url + "?imovelId=" + imovelAverbacao.getId());
    }

    public void redirect(String url, Long imovelId) throws IOException {
        ExternalContext context = FacesContext.getCurrentInstance().getExternalContext();
        context.redirect(url + "?imovelId=" + imovelId);
    }

    public void redirectRevisaoAlinhamento() throws IOException {
        ExternalContext context = FacesContext.getCurrentInstance().getExternalContext();
        context.redirect("revisaoalinhamento.xhtml?imovelId=" + visaoImovel.getId());
    }

    public void redirectAverbacao(String url) throws IOException {
        if (this.visaoImovel.getDimensoes().getAreaTotalEdificacao() == null) {
            Msg.messagemWarn("Para utilizar esse recurso o Imóvel deve possuir a Área Total Cadastrada");
        } else {
            ExternalContext context = FacesContext.getCurrentInstance().getExternalContext();
            context.redirect(url + "?imovelId=" + visaoImovel.getId());
        }
    }

    @Override
    public void remover() {
        try {
            imovelDelete.setUsuarioRemocao(usuarioServico.getCurrentUser());
            imovelDelete.setDataRemocao(new Date());
            imovelDelete.setAtivo(false);
            imovelServico.update(imovelDelete);

            Msg.messagemInfo(Msg.SuccessFull);
        } catch (EJBAccessException e) {
            Msg.messagemWarn(Msg.PermissaoNegada);
        }
    }

    public List<SelectItem> getPatrimonioList() {
        List<SelectItem> s = new ArrayList<SelectItem>();
        for (Patrimonio ms : Patrimonio.values()) {
            s.add(new SelectItem(ms, ms.getNome()));
        }
        return s;
    }
    private static int tamanhoMaximoNome = 10;

    public String nomeAnexo(Anexo a) {
        if (a.getNomeExibicao() != null) {
            if (a.getNomeExibicao().length() >= tamanhoMaximoNome) {
                return a.getNomeExibicao().substring(0, tamanhoMaximoNome).concat("...");
            }
            return a.getNomeExibicao().replace(".png", "").replace(" ", "_");
        }

        return a.getNome();
    }

    public String nomeAnexoPdf(Anexo a) {
        if (a.getNomeExibicao() != null) {
            if (a.getNomeExibicao().length() >= tamanhoMaximoNome) {
                return a.getNomeExibicao().substring(0, tamanhoMaximoNome).concat("...");
            }
            return a.getNomeExibicao().replace(".pdf", "").replace(" ", "_");
        }

        return a.getNome();
    }

    public String mascaraCpfCnpj(Proprietario p) {
        if (p.getTipoDocumento() != null) {
            if (p.getTipoDocumento().equals(TipoDocumento.CPF)) {
                return Caracter.addMask(p.getCpf(), Caracter.cpfMask);
            } else {
                return Caracter.addMask(p.getCnpj(), Caracter.cnpjMask);
            }
        }

        return "";
    }

    public List<Averbacao> getAverbacoes(Imovel imovel) {
        return averbacaoServico.getPorImovel(imovel);
    }

    public List<Forus> getLstForus() {
        List<Forus> forus = null;
        for (Averbacao avv : getAverbacoes(visaoImovel)) {
            forus = forusServico.forusByAverbacao(avv, visaoImovel);
        }
        return forus;
    }

    public void imprimir(Forus forus) throws IOException {
        forusServico.imprimirBoleto(forus);
    }

    public void imprimir() throws IOException {
        forusServico.imprimirBoletoForus(visaoImovel);
    }

    public List<Forus> getLstForusPendentes() {
        List<Forus> forus = null;
        for (Averbacao avv : getAverbacoes(visaoImovel)) {
            forus = forusServico.forusPendentes(avv, visaoImovel);
        }
        return forus;
    }

    public BigDecimal valorForus() {
        return forusServico.somaForus(visaoImovel);
    }

    public List<HistoricoRevisaoAlinhamento> getRevisaoAlinhamentos(Imovel imovel) {
        if (imovel != null) {
            return historicoRevisaoAlinhamentoServico.lstHistoricoRevisaoAlinhamento(imovel);
        }
        return null;
    }

    public void printRegistration(Averbacao registration) {
        HashMap parametros = new HashMap();
//        FacesContext facesContext = FacesContext.getCurrentInstance();
//        ServletContext servletContext = (ServletContext) facesContext.getExternalContext().getContext();
//        parametros.put("img", servletContext.getRealPath("/media/images/brasao.jpg"));
        parametros.putAll(prefeituraServico.parametroPrefeitura());

        averbacaoServico.imprimirAverbacao(registration, parametros);
    }

    public List<Bairro> getBairros() {
        List<Bairro> selectItems = new ArrayList<Bairro>();

        for (Bairro b : bairroServico.findAll()) {
            selectItems.add(b);
        }
        return selectItems;
    }

    public HashMap<String, String> getTipoPendencia() {

        HashMap<String, String> tipoPendencia = new HashMap<String, String>();
        tipoPendencia.put("Proprietário", "Proprietário");
        tipoPendencia.put("Documentos", "Documentos");

        return tipoPendencia;
    }

    public String pendencias(Imovel item) {
        List<String> pendencias = new ArrayList<String>();
        String pendencia = "";

        if (item.getProprietarios() == null || item.getProprietarios().isEmpty()) {
            pendencias.add("Não Existe Proprietário");
        }
        if (item.getAnnex() == null || item.getAnnex().isEmpty()) {
            pendencias.add(pendenteDocumentos);
        }

        for (int i = 0; i < pendencias.size(); i++) {

            if (pendencias.size() > 1 && i > 0) {
                if (i < pendencias.size() - 1) {
                    pendencia += ", ";
                } else {
                    pendencia += " e ";
                }
            }
            pendencia += pendencias.get(i);
        }

        return pendencia += ".";
    }

    public void gerarBoletos() throws IOException, Exception {
//        List<Imovel> list = new ArrayList<Imovel>();
//        list.add(visaoImovel);
//        iptuServico.gerarGuia( Lists.newArrayList( dataModel.iterator()) );
//    }
    }

    public boolean possuiIPTU() throws IOException {
        if (visaoImovel != null) {
            return !iptuServico.findIptuByImovelId(visaoImovel.getId()).isEmpty();
        }
        return false;
    }

    public void gerarCarne() {
//        List<Imovel> list = new ArrayList<Imovel>();
//
//        list.add(visaoImovel);
    }

    public void imprimirBoleto() throws IOException, Exception {
        if (iptuServico.imovelValido(visaoImovel)) {

            List<Imovel> list = new ArrayList<Imovel>();

            list.add(visaoImovel);
            iptuServico.gerarGuia(list);
        } else {
            Msg.messagemWarn("Boleto não gerado!");
        }
    }

    public void imprimirBoleto(Iptu i) throws IOException, Exception {
        List<Imovel> list = new ArrayList<Imovel>();

        list.add(visaoImovel);
        iptuServico.gerarGuia(list, i, null);
    }

    public void imprimirBoletoSetor() throws IOException, Exception {

        this.endereco.setCep(Caracter.removecaracter(this.endereco.getCep()));

        this.imovel.setEnderecoImovel(this.endereco);

        List<Imovel> list = imovelServico.find(imovel, null, null);

        if (list != null && !list.isEmpty()) {
            iptuServico.gerarGuia(list);
        }
    }

    public void calcularParcelas() throws IOException, Exception {
        List<Iptu> iptus = iptuServico.findIptuByImovelId(visaoImovel.getId());
        if (qtdParcelas != null && qtdParcelas > 0 && iptus != null && !iptus.isEmpty()) {
            Iptu iptu = iptus.get(0);
            parcelas.clear();
            if (qtdParcelas == 1) {
                qtdParcelas--;
            }
            parcelas.addAll(iptuServico.gerarParcelas(visaoImovel, iptu.getValorBaseCorrigido(), qtdParcelas, new Date()));
            Collections.sort(parcelas, new Comparator<Parcela>() {
                @Override
                public int compare(Parcela p1, Parcela p2) {
                    if (p1.getIndice() < p2.getIndice()) {
                        return -1;
                    } else {
                        return 1;
                    }
                }
            });
        }

    }

    public void imprimirNovoCarne() throws IOException, Exception {
        Iptu iptu = iptuServico.findIptuByImovelId(visaoImovel.getId()).get(0);
        List<Parcela> parcelasIptu = iptu.getParcelas();
        for (Parcela parcela : parcelasIptu) {
            parcela.setAtivo(false);
        }
        parcelasIptu.clear();
        if (qtdParcelas == 1) {
            qtdParcelas--;
        }
        parcelasIptu.addAll(iptuServico.gerarParcelas(visaoImovel, iptu.getValorBaseCorrigido(), qtdParcelas, new Date()));
        iptu.setParcelas(parcelasIptu);

        iptuServico.update(iptu);

        imprimirBoleto();
    }

    public void validaConfigItbi(Imovel imovel) {
        if (imovel == null) {
            imovel = visaoImovel;
        }

        try {
            itbiServico.validaConfigItbi();
            try {
                itbiServico.validaImovel(imovel);
                try {
                    redirect("geraritbi.xhtml", imovel.getId());
                } catch (IOException ex) {
                    Logger.getLogger(ManagerPesquisarImovel.class.getName()).log(Level.SEVERE, null, ex);
                }

            } catch (Exception e1) {
                Msg.messagemError(e1.getMessage());
            }
        } catch (Exception e2) {
            Msg.messagemError(e2.getMessage());

        }
    }

    public Imovel getImovel() {
        return imovel;
    }

    public void setImovel(Imovel imovel) {
        this.imovel = imovel;
    }

    public List<Imovel> getImoveis() {
        return imoveis;
    }

    public void setImoveis(List<Imovel> imoveis) {
        this.imoveis = imoveis;
    }

    public Proprietario getProprietario() {
        return proprietario;
    }

    public void setProprietario(Proprietario proprietario) {
        this.proprietario = proprietario;
    }

    public Endereco getEndereco() {
        return endereco;
    }

    public void setEndereco(Endereco endereco) {
        this.endereco = endereco;
    }

    public Imovel getVisaoImovel() {
        return visaoImovel;
    }

    public void setVisaoImovel(Imovel visaoImovel) {
        this.visaoImovel = visaoImovel;
    }

    public List<Anexo> getAnnexs() {
        return annexs;
    }

    public void setAnnexs(List<Anexo> annexs) {
        this.annexs = annexs;
    }

    public LatLng getLatlong() {
        return latlong;
    }

    public void setLatlong(LatLng latlong) {
        this.latlong = latlong;
    }

    public Coordenada getCoordenada() {
        return coordenada;
    }

    public void setCoordenada(Coordenada coordenada) {
        this.coordenada = coordenada;
    }

    public List<Coordenada> getCoordenadas() {
        return coordenadas;
    }

    public void setCoordenadas(List<Coordenada> coordenadas) {
        this.coordenadas = coordenadas;
    }

    public MapModel getMapModel() {
        return mapModel;
    }

    public void setMapModel(MapModel mapModel) {
        this.mapModel = mapModel;
    }

    public Coordenada getVisualizarCoordenada() {
        return visualizarCoordenada;
    }

    public void setVisualizarCoordenada(Coordenada visualizarCoordenada) {
        this.visualizarCoordenada = visualizarCoordenada;
    }

    public Imovel getImovelAverbacao() {
        return imovelAverbacao;
    }

    public void setImovelAverbacao(Imovel imovelAverbacao) {
        this.imovelAverbacao = imovelAverbacao;
    }

    public Imovel getImovelDelete() {
        return imovelDelete;
    }

    public void setImovelDelete(Imovel imovelDelete) {
        this.imovelDelete = imovelDelete;
    }

    public String getVisaoInscricao() {
        return visaoInscricao;
    }

    public void setVisaoInscricao(String visaoInscricao) {
        this.visaoInscricao = visaoInscricao;
    }

    public List<Imovel> getImoveisPendentes() {
        return imoveisPendentes;
    }

    public void setImoveisPendentes(List<Imovel> imoveisPendentes) {
        this.imoveisPendentes = imoveisPendentes;
    }

    public List<Imovel> getResultPendentes() {
        return resultPendentes;
    }

    public void setResultPendentes(List<Imovel> resultPendentes) {
        this.resultPendentes = resultPendentes;
    }

    public PieChartModel getGraficoModel() {
        return graficoModel;
    }

    public void setGraficoModel(PieChartModel graficoModel) {
        this.graficoModel = graficoModel;
    }

    public String getGrupo() {
        return grupo;
    }

    public void setGrupo(String grupo) {
        this.grupo = grupo;
    }

    public Bairro getBairro() {
        return bairro;
    }

    public void setBairro(Bairro bairro) {
        this.bairro = bairro;
    }

    public List<String> getSelectedOptions() {
        return selectedOptions;
    }

    public void setSelectedOptions(List<String> selectedOptions) {
        this.selectedOptions = selectedOptions;
    }

    public List<Anexo> getAnnexCroquis() {
        return annexCroquis;
    }

    public void setAnnexCroquis(List<Anexo> annexCroquis) {
        this.annexCroquis = annexCroquis;
    }

    public boolean isConnect() {
        return connect;
    }

    public void setConnect(boolean connect) {
        this.connect = connect;
    }

    public Integer getZoom() {
        return zoom;
    }

    public void setZoom(Integer zoom) {
        this.zoom = zoom;
    }

    public boolean isBtGerarIptu() {
        return btGerarIptu;
    }

    public void setBtGerarIptu(boolean btGerarIptu) {
        this.btGerarIptu = btGerarIptu;
    }

    public List<Iptu> getLstIptus() {
        return lstIptus;
    }

    public BigDecimal getValorIptu() {
        List<Iptu> iptus = iptuServico.findIptuByImovelId(visaoImovel.getId());
        if (iptus != null || !iptus.isEmpty()) {
            BigDecimal valorIptu = iptus.get(0).getValorBaseCorrigido().setScale(2, RoundingMode.HALF_DOWN);
            return valorIptu;
        }
        return BigDecimal.ZERO;
    }

    public void setLstIptus(List<Iptu> lstIptus) {
        this.lstIptus = lstIptus;
    }

    public Integer getQtdParcelas() {
        return qtdParcelas;
    }

    public void setQtdParcelas(Integer qtdParcelas) {
        this.qtdParcelas = qtdParcelas;
    }

    public List<Parcela> getParcelas() {
        return parcelas;
    }

    public void setParcelas(ArrayList<Parcela> parcelas) {
        this.parcelas = parcelas;
    }

    public boolean isSoResultado() {
        return soResultado;
    }

    public void setSoResultado(boolean soResultado) {
        this.soResultado = soResultado;
    }

    public Proprietario getProprietarioVisualizar() {
        return proprietarioVisualizar;
    }

    public void setProprietarioVisualizar(Proprietario proprietarioVisualizar) {
        this.proprietarioVisualizar = proprietarioVisualizar;
    }

    public boolean isPessoaFisica() {
        if (proprietarioVisualizar.getTipoDocumento() == null) {
            proprietarioVisualizar.setTipoDocumento(TipoDocumento.CPF);
        }

        return proprietarioVisualizar.getTipoDocumento().equals(TipoDocumento.CPF);
    }

    public void pesquisaPrincipal() {
        if (cpf != null || inscricaoImovel != null) {
            if (cpf != null) {
                proprietario.setCpf(cpf);
            }
            if (visaoInscricao != null) {

                if (this.inscricaoImovel != null && !this.inscricaoImovel.contains(".")) {
                    visaoInscricao = "";
                    visaoInscricao += inscricaoImovel.substring(0, 2).concat(".");
                    visaoInscricao += inscricaoImovel.substring(2, 4).concat(".");
                    visaoInscricao += inscricaoImovel.substring(4, 7).concat(".");
                    visaoInscricao += inscricaoImovel.substring(7, 11).concat(".");
                    visaoInscricao += inscricaoImovel.substring(11);
                } else {
                    visaoInscricao = inscricaoImovel;
                }

            }
            soResultado = true;
            pesquisarImovel();
        }
    }

    public TreeMap<String, String> getSelectParcelas() {
        return selectParcelas;
    }

    public void setSelectParcelas(TreeMap<String, String> selectParcelas) {
        this.selectParcelas = selectParcelas;
    }

    private void atualizarAnexos(List<Anexo> annexs) {

        for (Anexo anexo : annexs) {

            if (anexo.getNome() != null) {

                String nome = anexo.getNome();

                if (anexo.getNome().contains(" ")) {
                    anexo.setNome(anexo.getNome().trim().replace(" ", "_"));
                }
                
                if (!anexo.getNome().endsWith(".jpg") && !anexo.getNome().endsWith(".jpeg")
                        && !anexo.getNome().endsWith(".gif") && !anexo.getNome().endsWith(".pdf")
                        && !anexo.getNome().endsWith(".png")) {

                    SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy-HH-mm-ss-SSSS");
                    String data = dateFormat.format(new Date());

                    anexo.setNome(data + anexo.getNome() + ".jpg");
                }

                File file = new File(anexo.getUrl() + nome);

                if (file.exists()) {
                    file.renameTo(new File(anexo.getUrl() + anexo.getNome()));

                    ArquivoUtilitario.criarMiniatura(anexo.getUrl() + anexo.getNome());

                    anexoServico.update(anexo);
                }
            }
        }
    }

    class ValueComparator implements Comparator<String> {

        Map<String, String> base;

        public ValueComparator(Map<String, String> base) {
            this.base = base;
        }

        @Override
        public int compare(String a, String b) {
            if (base.get(a).length() == base.get(b).length()) {
                return base.get(a).compareToIgnoreCase(base.get(b));
            } else {
                if (base.get(a).length() > base.get(b).length()) {
                    return 1;
                } else {
                    return -1;
                }
            }
        }
    }

    public void gerarForus(Imovel imovel) {


        Double indice = 0.020;
        Double areaTotal = imovel.getDimensoes().getAreaTerreno().doubleValue();
        Double total = areaTotal * indice;

        List<Averbacao> averbacoes = averbacaoServico.getPorImovel(imovel);
        if (!averbacoes.isEmpty()) {
            Forus forus = null;
            for (Averbacao avv : averbacoes) {
                forus = forusServico.possuiForus(avv);
            }
            if (forus != null) {
                org.primefaces.context.RequestContext.getCurrentInstance().execute("dlgForus.show()");
            } else {
                Forus forusSave = new Forus();
                forusSave.setAverbacao(forus.getAverbacao());
                forusSave.setValor(new BigDecimal(total));
                forusSave.setDataForus(new Date());
                forusSave.setPago(Boolean.FALSE);
                forusServico.save(forusSave);
            }
        } else {
            org.primefaces.context.RequestContext.getCurrentInstance().execute("dlgNForus.show()");
        }
//        } 
//        else {
//            Forus forus = new Forus();
//            forus.setAverbacao(averbacao);
//            forus.setValor(BigDecimal.TEN);
//            forus.setDataForus(new Date());
//            forusServico.save(forus);
//        }
    }

    public String inscricaoCadastral(Imovel imovel) {

        String inscricao = "";
        DecimalFormat d = new DecimalFormat("");
        d.setMinimumIntegerDigits(2);

        inscricao += d.format(imovel.getInscricaoCadastralD() == null ? 0 : imovel.getInscricaoCadastralD());
        inscricao += ".";
        inscricao += d.format(imovel.getInscricaoCadastralS() == null ? 0 : imovel.getInscricaoCadastralS());
        inscricao += ".";
        d.setMinimumIntegerDigits(3);
        inscricao += d.format(imovel.getInscricaoCadastralQuadra() == null ? 0 : imovel.getInscricaoCadastralQuadra());
        inscricao += ".";
        d.setMinimumIntegerDigits(4);
        d.setDecimalSeparatorAlwaysShown(false);
        inscricao += d.format(imovel.getInscricaoCadastralLote() == null ? 0 : imovel.getInscricaoCadastralLote()).replaceAll("\\.", "");
        inscricao += ".";
        d.setMinimumIntegerDigits(2);
        inscricao += d.format(imovel.getInscricaoCadastralUnid() == null ? 0 : imovel.getInscricaoCadastralUnid());

        inscricao = inscricao.replace(",", "");

        return inscricao;
    }

    public boolean isRegistroAlteracao() {
        return registroAlteracao;
    }

    public void setRegistroAlteracao(boolean registroAlteracao) {
        this.registroAlteracao = registroAlteracao;
    }

    public boolean isInclusao() {
        return inclusao;
    }

    public void setInclusao(boolean inclusao) {
        this.inclusao = inclusao;
    }

    public boolean isAlteracao() {
        return alteracao;
    }

    public void setAlteracao(boolean alteracao) {
        this.alteracao = alteracao;
    }

    public void atualizarTipoRegistro(boolean tipoInclusao) {

        if (tipoInclusao && this.inclusao) {
            this.alteracao = false;
        } else if (!tipoInclusao && this.alteracao) {
            this.inclusao = false;
        }

        if (this.inclusao) {
            this.imovel.setComando(Comando.INCLUSAO);
        } else if (this.alteracao) {
            this.imovel.setComando(Comando.ALTERACAO);
        } else {
            this.imovel.setComando(null);
        }
    }

    public Boolean getImovelComNumero() {
        return imovelComNumero;
    }

    public void setImovelComNumero(Boolean imovelComNumero) {
        this.imovelComNumero = imovelComNumero;
    }

    public Boolean getImovelComCroqui() {
        return imovelComCroqui;
    }

    public void setImovelComCroqui(Boolean imovelComCroqui) {
        this.imovelComCroqui = imovelComCroqui;
    }

    public Boolean getImovelComAnexo() {
        return imovelComAnexo;
    }

    public void setImovelComAnexo(Boolean imovelComAnexo) {
        this.imovelComAnexo = imovelComAnexo;
    }

    public Boolean getImovelComProprietario() {
        return imovelComProprietario;
    }

    public void setImovelComProprietario(Boolean imovelComProprietario) {
        this.imovelComProprietario = imovelComProprietario;
    }

    public void verificarNumeroEnderecoImovel() {
        if (this.imovelComNumero != null && !this.imovelComNumero) {
            this.endereco.setNumero(null);
        }
    }

    public List<Bairro> autocompleteMultipleBairro(String query) {
        return bairroServico.autocomplete(query, this.bairrosSelecionados);
    }

    public void adicionarBairroSelecionado(SelectEvent e) {
        this.bairrosSelecionados.add((Bairro) e.getObject());
    }

    public void removerBairroSelecionado(UnselectEvent e) {
        this.bairrosSelecionados.remove((Bairro) e.getObject());
    }

    public void reloadImagem(String cod) throws Exception {
        URL url = new URL("http://192.168.1.101:8080/ProblemaAnexo-war/show/?cod=");

        HttpURLConnection urlConn = urlConn = (HttpURLConnection) url.openConnection();

        urlConn.setDoInput(true);

        urlConn.setDoOutput(true);

        urlConn.setRequestMethod("POST");

        urlConn.setRequestProperty("Content-Type", "application/json");

        urlConn.connect();

        DataOutputStream output = new DataOutputStream(urlConn.getOutputStream());

        DataInputStream input;


        /*
         * Construct the POST data.
         */
        String content = cod.replaceAll("#", "_");

        /*
         * Send the request data.
         */
        output.writeBytes(content);
        output.flush();
        output.close();

        /*
         * Get response data.
         */
        String response = null;
        input = new DataInputStream(urlConn.getInputStream());
        while (null != ((response = input.readLine()))) {
            System.out.println(response);
            input.close();
        }

        annexs = imovelServico.lstAnnexs(visaoImovel);
    }

    /**
     * Pesquisa o próximo Imóvel com id maior que o do Imóvel que está sendo visualizado e redireciona a página para o
     * mesmo.
     */
    public void proximoImovel() {

        ExternalContext context = FacesContext.getCurrentInstance().getExternalContext();

        try {

            Long id = imovelServico.pesquisarProximoImovel(this.visaoImovel.getId());

            context.redirect("visualizarimovel.xhtml?vImovel=" + id);

        } catch (IOException e) {
            System.err.println(e);
        }
    }

    /**
     * Pesquisa o Imóvel anterior com id menor que o do Imóvel que está sendo visualizado e redireciona a página para o
     * mesmo.
     */
    public void imovelAnterior() {

        ExternalContext context = FacesContext.getCurrentInstance().getExternalContext();

        try {

            Long id = imovelServico.pesquisarImovelAnterior(this.visaoImovel.getId());

            context.redirect("visualizarimovel.xhtml?vImovel=" + id);

        } catch (IOException ex) {
            Logger.getLogger(Msg.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public Long getProximoImovel() {
        return proximoImovel;
    }

    public void setProximoImovel(Long proximoImovel) {
        this.proximoImovel = proximoImovel;
    }

    public Long getImovelAnterior() {
        return imovelAnterior;
    }

    public void setImovelAnterior(Long imovelAnterior) {
        this.imovelAnterior = imovelAnterior;
    }

    /**
     * Métodos para pesquisa seleção de imoveis para merge
     */
    public void registroAlteracao() throws IOException {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        String param = "/Atlas-war/pesquisarimovel.xhtml?";
        param += "inscricaoimovel=" + visaoInscricao + "&vReg=true";
        facesContext.getExternalContext().redirect(param);
    }

    public void redirectAtualizarCadastro() throws IOException {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        String param = "/Atlas-war/atualizarcadastro.xhtml?";
        param += "idImovelAlt=" + this.imovelSelected.getId();
        facesContext.getExternalContext().redirect(param);
    }

    public Imovel getImovelSelected() {
        return imovelSelected;
    }

    public void setImovelSelected(Imovel imovelSelected) {
        this.imovelSelected = imovelSelected;
    }

    public String getvReg() {
        return vReg;
    }

    public void setvReg(String vReg) {
        this.vReg = vReg;
    }

    public Boolean getImovelComDimensoes() {
        return imovelComDimensoes;
    }

    public void setImovelComDimensoes(Boolean imovelComDimensoes) {
        this.imovelComDimensoes = imovelComDimensoes;
    }

    public Boolean getImovelComConfrontacao() {
        return imovelComConfrontacao;
    }

    public void setImovelComConfrontacao(Boolean imovelComConfrontacao) {
        this.imovelComConfrontacao = imovelComConfrontacao;
    }

    public void atualizarLstIptus() {
        lstIptus = iptus(visaoImovel);
    }

    public String getInscricaoCadastralQuadra() {
        return inscricaoCadastralQuadra;
    }

    public void setInscricaoCadastralQuadra(String inscricaoCadastralQuadra) {
        this.inscricaoCadastralQuadra = inscricaoCadastralQuadra;
    }

    public String getCenterDimensao() {
        return centerDimensao;
    }

    public void setCenterDimensao(String centerDimensao) {
        this.centerDimensao = centerDimensao;
    }

    public Integer getZoomDimensao() {
        return zoomDimensao;
    }

    public void setZoomDimensao(Integer zoomDimensao) {
        this.zoomDimensao = zoomDimensao;
    }

    public MapModel getMapModelDimensao() {
        return mapModelDimensao;
    }

    public void setMapModelDimensao(MapModel mapModelDimensao) {
        this.mapModelDimensao = mapModelDimensao;
    }

    public Boolean getImovelComCoordenadasDimensoes() {
        return imovelComCoordenadasDimensoes;
    }

    public void setImovelComCoordenadasDimensoes(Boolean imovelComCoordenadasDimensoes) {
        this.imovelComCoordenadasDimensoes = imovelComCoordenadasDimensoes;
    }

    public void imprimirBci() {
//        if (visaoImovel.getSituacaoImovel() != null && !visaoImovel.getSituacaoImovel().equals(SituacaoImovel.APTO)) {
//            Msg.messagemWarn("Este imóvel não está Apto para Regularização Fundiária!");
//            return;
//        }

        RequestContext.getCurrentInstance().execute("dlgBCI.show();");
    }

    public List<Integer> formatarInscricaoCadastralQuadras() {

        if ((this.inscricaoImovel != null && !this.inscricaoImovel.isEmpty()) || this.inscricaoCadastralQuadra == null) {
            return new ArrayList<Integer>();
        }

        String[] inscricaoCadastralQuadras = this.inscricaoCadastralQuadra.trim().split(";");
        String[] sequenciaQuadra;
        List<Integer> quadras = new ArrayList<Integer>();

        if (inscricaoCadastralQuadras.length == 1 && !inscricaoCadastralQuadras[0].contains(",") && !inscricaoCadastralQuadras[0].contains("-")
                && inscricaoCadastralQuadras[0] != null && !inscricaoCadastralQuadras[0].isEmpty()) {
            quadras.add(Integer.parseInt(inscricaoCadastralQuadras[0]));
            return quadras;
        }

        for (String sequencia : inscricaoCadastralQuadras) {

            if (sequencia.trim().contains(",")) {

                sequenciaQuadra = sequencia.trim().split(",");

                if (sequenciaQuadra.length == 1) {
                    Msg.messagemError("Você digitou uma sequência inválida no campo Quadra !");
                    return null;
                }

                for (String string : sequenciaQuadra) {
                    quadras.add(Integer.parseInt(string));
                }

            } else if (sequencia.trim().contains("-")) {
                sequenciaQuadra = sequencia.trim().split("-");

                if (sequenciaQuadra.length == 1 || sequenciaQuadra.length > 2) {
                    Msg.messagemError("Você digitou uma sequência inválida no campo Quadra !");
                    return null;
                }

                if (Integer.parseInt(sequenciaQuadra[0]) > Integer.parseInt(sequenciaQuadra[1])) {
                    for (int i = Integer.parseInt(sequenciaQuadra[1]); i <= Integer.parseInt(sequenciaQuadra[0]); i++) {
                        quadras.add(new Integer(i));
                    }
                } else {
                    for (int i = Integer.parseInt(sequenciaQuadra[0]); i <= Integer.parseInt(sequenciaQuadra[1]); i++) {
                        quadras.add(new Integer(i));
                    }
                }
            } else if (sequencia != null && !sequencia.isEmpty()) {
                quadras.add(new Integer(sequencia));
            }
        }

        return quadras;
    }
}
